#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>
#include <iostream>
#include <string>
#include <unistd.h>
#include <pthread.h>
#include <cstdio>

#include <iostream>
#include <pthread.h>
#include <unistd.h>

// 任务类：封装两个整数的加法操作
class Task
{
public:
    Task(int a, int b) : _a(a), _b(b) {}
    int Execute() { return _a + _b; } // 执行加法计算
    ~Task() {} // 析构函数（可添加打印验证释放）

private:
    int _a;
    int _b;
};

// 结果类：封装任务执行结果
class Result
{
public:
    Result(int result) : _result(result) {}
    int GetResult() { return _result; }
    ~Result() {} // 析构函数（可添加打印验证释放）

private:
    int _result;
};

// 线程入口函数：处理任务并返回结果
void* routine(void* args)
{
    // 接收任务指针并转换类型
    Task* t = static_cast<Task*>(args);
    if (t == nullptr) {
        return nullptr; // 异常处理：参数为空时直接返回
    }

    // 模拟任务执行耗时
    sleep(1);

    // 执行任务并创建结果对象
    int sum = t->Execute();
    Result* res = new Result(sum);

    // 释放任务对象（核心修复：线程内使用后立即释放）
    delete t;
    t = nullptr;

    // 模拟后续处理耗时
    sleep(1);

    return res; // 返回结果指针
}

int main()
{
    pthread_t tid;
    // 创建任务对象（动态分配，所有权将转移给线程）
    Task* t = new Task(10, 20);

    // 创建线程：将任务指针传入线程函数
    if (pthread_create(&tid, nullptr, routine, t) != 0) {
        std::cerr << "线程创建失败！" << std::endl;
        delete t; // 仅在线程创建失败时释放任务（此时线程未获取所有权）
        return -1;
    }

    // 等待线程结束并获取返回结果
    Result* ret = nullptr;
    if (pthread_join(tid, reinterpret_cast<void**>(&ret)) != 0) {
        std::cerr << "线程等待失败！" << std::endl;
        return -1; // 线程已创建成功时，任务已由线程释放，无需在此处理
    }

    // 输出结果并释放结果对象
    if (ret != nullptr) {
        std::cout << "新线程结束，运行结果: " << ret->GetResult() << std::endl;
        delete ret; // 释放结果对象
        ret = nullptr;
    }

    return 0;
}

// int flag = 100;

// void showtid(pthread_t &tid)
// {
//     printf("tid: 0x%lx\n", tid);
// }

// std::string FormatId(const pthread_t &tid)
// {
//     char id[64];
//     snprintf(id, sizeof(id), "0x%lx", tid);
//     return id;
// }

// void *routine(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     pthread_t tid = pthread_self();
//     int cnt = 5;
//     while (cnt)
//     {
//         std::cout << "我是一个新线程: 我的名字是: " << name << " 我的Id是: " << FormatId(tid) << std::endl;
//         sleep(1);
//         cnt--;
//         flag++;
//     }
//     return (void *)123; // 暂时表示线程退出的时候的退出码
// }

// int main()
// {
//     pthread_t tid;
//     int n = pthread_create(&tid, nullptr, routine, (void *)"thread-1");
//     (void)n;

//     showtid(tid);
//     int cnt = 5;
//     while (cnt)
//     {
//         std::cout << "我是main线程: 我的名字是: main thread" << " 我的Id是: " << FormatId(pthread_self()) << "flag: " << flag << std::endl;
//         sleep(1);
//         cnt--;
//     }
//     void *ret = nullptr; // ret也是一个变量，也是有空间的！！！
//     // 等待的目标线程，如果异常了，整个进程都退出了，包括main线程，所以，join异常，没有意义，看也看不到！
//     // jion都是基于：线程健康跑完的情况，不需要处理异常信号，异常信号，是进程要处理的话题！！！
//     pthread_join(tid, &ret);                                    // 为什么在join的时候，没有见到异常相关的字段呢？？
//     std::cout << "ret is: " << (long long int)ret << std::endl; // 要使用的就是ret的空间，因为ret是一个指针，所以打印要转成long long int
//     return 0;
// }

// void* threadrun(void* args) {
//     std::string name = (const char*)args;
//     while(1) {
//         sleep(1);
//         std::cout << "我是新线程: name == " << name << std::endl;
//     }
// }

// int main() {
//     pthread_t id;
//     pthread_create(&id, nullptr, threadrun, (void*)"thread-1");
//     while(1) {
//         std::cout << "我是主线程..." << std::endl;
//         sleep(1);
//     }
//     return 0;
// }